package com.lh.utils;

import cn.hutool.core.collection.CollectionUtil;
import com.lh.entity.table.RectificationInfo;
import com.lh.entity.vo.RectificationInfoDirTreeVo;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 将RectificationInfo列表转换为三层树结构的工具类
 * 使用RectificationInfoDirTreeVo作为树节点
 */
public class RectificationTreeConverter {

    /**
     * 将RectificationInfo列表转换为三层树结构
     * @param rectificationList 原始数据列表
     * @return 树结构列表
     */
    public static List<RectificationInfoDirTreeVo> convertToTree(List<RectificationInfo> rectificationList) {
        if (CollectionUtil.isEmpty(rectificationList)) {
            return new ArrayList<>();
        }

        // 第一层分组：按projectType
        Map<String, List<RectificationInfo>> projectTypeGroups =
                rectificationList.stream()
                        .collect(Collectors.groupingBy(RectificationInfo::getProjectType));

        List<RectificationInfoDirTreeVo> rootNodes = new ArrayList<>();

        // 处理每个projectType组，创建第一层节点
        for (Map.Entry<String, List<RectificationInfo>> projectTypeEntry : projectTypeGroups.entrySet()) {
            String projectType = projectTypeEntry.getKey();
            List<RectificationInfo> projectTypeList = projectTypeEntry.getValue();

            // 创建第一层节点
            RectificationInfoDirTreeVo firstLevelNode = new RectificationInfoDirTreeVo();
            firstLevelNode.setName(projectType);
            firstLevelNode.setCount(projectTypeList.size()); // 统计该类型下的总数量
            firstLevelNode.setChild(new ArrayList<>());

            // 第二层分组：按projectChildType
            Map<String, List<RectificationInfo>> childTypeGroups =
                    projectTypeList.stream()
                            .collect(Collectors.groupingBy(RectificationInfo::getProjectChildType));

            // 处理每个projectChildType组，创建第二层节点
            for (Map.Entry<String, List<RectificationInfo>> childTypeEntry : childTypeGroups.entrySet()) {
                String projectChildType = childTypeEntry.getKey();
                List<RectificationInfo> childTypeList = childTypeEntry.getValue();

                // 创建第二层节点
                RectificationInfoDirTreeVo secondLevelNode = new RectificationInfoDirTreeVo();
                secondLevelNode.setName(projectChildType);
                secondLevelNode.setCount(childTypeList.size()); // 统计该子类型下的数量
                secondLevelNode.setChild(new ArrayList<>());

                // 检查是否有非空的projectChildCategoryType
                boolean hasCategory = childTypeList.stream()
                        .anyMatch(info -> info.getProjectChildCategoryType() != null
                                && !info.getProjectChildCategoryType().trim().isEmpty());

                // 如果有非空的projectChildCategoryType，则创建第三层节点
                if (hasCategory) {
                    // 第三层分组：按projectChildCategoryType
                    Map<String, List<RectificationInfo>> categoryGroups =
                            childTypeList.stream()
                                    .filter(info -> info.getProjectChildCategoryType() != null
                                            && !info.getProjectChildCategoryType().trim().isEmpty())
                                    .collect(Collectors.groupingBy(RectificationInfo::getProjectChildCategoryType));

                    // 处理每个projectChildCategoryType组，创建第三层节点
                    for (Map.Entry<String, List<RectificationInfo>> categoryEntry : categoryGroups.entrySet()) {
                        String categoryType = categoryEntry.getKey();
                        List<RectificationInfo> categoryList = categoryEntry.getValue();

                        // 创建第三层节点
                        RectificationInfoDirTreeVo thirdLevelNode = new RectificationInfoDirTreeVo();
                        thirdLevelNode.setName(categoryType);
                        thirdLevelNode.setCount(categoryList.size()); // 统计该分类下的数量
                        thirdLevelNode.setChild(new ArrayList<>()); // 第三层没有子节点

                        // 添加到第二层节点的子节点
                        secondLevelNode.getChild().add(thirdLevelNode);
                    }
                }
                // 如果没有projectChildCategoryType，第二层节点的child保持为空列表

                // 将第二层节点添加到第一层节点
                firstLevelNode.getChild().add(secondLevelNode);
            }

            // 将第一层节点添加到根节点列表
            rootNodes.add(firstLevelNode);
        }

        // 按名称排序，使结果更有序
        sortTreeNodes(rootNodes);

        return rootNodes;
    }

    /**
     * 递归排序树节点
     */
    private static void sortTreeNodes(List<RectificationInfoDirTreeVo> nodes) {
        if (CollectionUtil.isEmpty(nodes)) {
            return;
        }

        // 按名称升序排序当前层级节点
        nodes.sort(Comparator.comparing(RectificationInfoDirTreeVo::getName));

        // 递归排序子节点
        for (RectificationInfoDirTreeVo node : nodes) {
            sortTreeNodes(node.getChild());
        }
    }
}
